package com.hwapitest.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONPath;
import com.alibaba.fastjson.JSONObject;
import com.hwapitest.testcase.BaseCase;
import org.apache.log4j.Logger;
import org.testng.Assert;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 全局变量工具类：支持JSONPath提取（适配FastJSON 2.x）
 */
public class GlobalVariableUtil {
    public static Logger logger = Logger.getLogger(GlobalVariableUtil.class);

    // 正则匹配JSONPath表达式（如$.data.token）
    private static final Pattern JSON_PATH_PATTERN = Pattern.compile("^\\$\\.([a-zA-Z0-9_.\\[\\]]+)$");

    /**
     * 从全局map中获取全局变量并替换（格式：${key}）
     */
    public static String substitutionGlobalVariable(String param) {
        if (!StringUtil.isNotNullAndEmpty(param)) {
            return "";
        }
        Matcher matcher = BaseCase.replaceParamPattern.matcher(param);
        StringBuffer result = new StringBuffer();

        while (matcher.find()) {
            String replaceKey = matcher.group(1).trim();
            if (!BaseCase.globalVariableMap.containsKey(replaceKey)) {
                logger.error("全局变量替换失败：未找到key='" + replaceKey + "'对应的值");
                Assert.fail("全局变量替换失败：key='" + replaceKey + "'不存在");
            }
            String value = BaseCase.globalVariableMap.get(replaceKey);
            matcher.appendReplacement(result, Matcher.quoteReplacement(value));
        }
        matcher.appendTail(result);
        return result.toString();
    }

    /**
     * 保存全局变量（支持JSONPath提取，如token=$.data.token）
     */
    public static void saveGlobalVariable(String actual, String globalVariables) {
        logger.info("===== 开始保存全局变量 =====");
        logger.info("原始响应内容: " + actual);
        logger.info("变量定义字符串: " + globalVariables);

        // 空值处理
        if (actual == null) actual = "";
        if (!StringUtil.isNotNullAndEmpty(globalVariables)) {
            logger.error("变量定义字符串为空");
            Assert.fail("global variable format error");
            return;
        }

        // 预处理响应内容（去除首尾等号，避免解析错误）
        actual = actual.trim().replaceAll("^=+|=+$", "");

        // 支持逗号和分号分隔变量（如key1=value1;key2=value2）
        String[] variableEntries = globalVariables.split("[,;]");
        for (String entry : variableEntries) {
            processVariableEntry(entry, actual);
        }
    }

    /**
     * 处理单个变量条目（如token=$.data.token）
     */
    private static void processVariableEntry(String entry, String actual) {
        String trimmedEntry = entry.trim();

        // 跳过注释行（#开头）和空行
        if (trimmedEntry.isEmpty() || trimmedEntry.startsWith("#")) {
            logger.debug("跳过注释行或空行: " + entry);
            return;
        }

        // 分割key和value（格式：key=valueExpr）
        String[] parts = trimmedEntry.split("=", 2);
        if (parts.length != 2) {
            logger.error("变量格式错误（需为key=value）: " + entry);
            return;
        }

        String key = parts[0].trim();
        String valueExpr = parts[1].trim();

        // 校验key和value表达式非空
        if (key.isEmpty() || valueExpr.isEmpty()) {
            logger.error("变量名或表达式为空: " + entry);
            return;
        }

        // 解析value表达式（支持JSONPath和常量）
        String resolvedValue = resolveValueExpression(valueExpr, actual);

        // 保存到全局变量Map
        BaseCase.globalVariableMap.put(key, resolvedValue);
        logger.info("成功保存全局变量: " + key + "=" + resolvedValue);
    }

    /**
     * 解析value表达式（支持JSONPath提取，如$.data.token）
     */
    private static String resolveValueExpression(String valueExpr, String actual) {
        // 1. 匹配JSONPath表达式（如$.data.token）
        Matcher jsonPathMatcher = JSON_PATH_PATTERN.matcher(valueExpr);
        if (jsonPathMatcher.matches()) {
            String jsonPath = "$." + jsonPathMatcher.group(1); // 补全JSONPath前缀（如$.data.token）
            return extractJsonValue(actual, jsonPath);
        }

        // 2. 匹配全局变量占位符（如${token}）
        if (valueExpr.contains("${")) {
            return substitutionGlobalVariable(valueExpr);
        }

        // 3. 普通常量（直接返回）
        return valueExpr;
    }

    /**
     * 核心：使用JSONPath从响应中提取值（适配FastJSON 2.x）
     */
    private static String extractJsonValue(String jsonResponse, String jsonPath) {
        try {
            // 解析JSON响应（FastJSON 2.x的JSON.parse）
            Object parsedJson = JSON.parse(jsonResponse);

            // 使用JSONPath提取值（FastJSON 2.x的JSONPath.eval）
            Object result = JSONPath.eval(parsedJson, jsonPath);

            // 处理空结果
            if (result == null) {
                logger.warn("JSONPath提取结果为空: " + jsonPath);
                return "";
            }

            // 根据结果类型返回字符串值
            if (result instanceof String) {
                return (String) result;
            } else if (result instanceof Number) {
                return result.toString();
            } else if (result instanceof Boolean) {
                return result.toString();
            } else {
                // 对于JSONObject、JSONArray等复杂类型，转换为JSON字符串
                return JSON.toJSONString(result);
            }
        } catch (Exception e) {
            logger.error("JSONPath提取失败: " + jsonPath, e);
            return ""; // 提取失败返回空字符串，避免影响后续流程
        }
    }
}
